﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Generic.Contract;
using Generic.Data.Manager;
using Contract.Business.Entity;
using Contract.Business.Filter;
using DataEntity;

namespace Contract.Data.Manager
{
    //Criado por : Gustavo
    //Data       : 9/24/2012 9:14:02 PM
    public class DMEnderecoCliente : DMGeneric<BEEnderecoCliente, FEEnderecoCliente>
    {
        databaseDataContext dc;

        #region Override

        public override BEEnderecoCliente Salvar(BEEnderecoCliente entidade)
        {
            try
            {
                if (entidade.Codigo.Equals(0))
                    entidade.Codigo = Incluir(entidade);
                else
                    Alterar(entidade);

                return entidade;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public override void Excluir(BEEnderecoCliente entidade)
        {
            try
            {
                using (dc = new databaseDataContext())
                {

                    var q = from r in dc.DEEnderecoClientes
                            where
                                r.Codigo == entidade.Codigo
                            select r;

                    DEEnderecoCliente de = q.First();

                    dc.DEEnderecoClientes.DeleteOnSubmit(de);
                    dc.SubmitChanges();
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        public override BEEnderecoCliente ObterEntidade(int codigo)
        {
            try
            {
                using (dc = new databaseDataContext())
                {
                    var q = from e in dc.DEEnderecoClientes
                            where
                                e.Codigo == codigo
                            select e;

                    return q.First().ConvertToBE(1);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        public override List<BEEnderecoCliente> ObterTodos(FEEnderecoCliente filter)
        {
            try
            {
                using (dc = new databaseDataContext())
                {

                    var q = from e in dc.DEEnderecoClientes
                            where
                            (
                                (((filter.CodigoCliente != null)
                                && (e.CodigoCliente == filter.CodigoCliente)) || (filter.CodigoCliente == null)) &&

                                (((filter.Endereco != null)
                                && (e.Endereco.Contains(filter.Endereco))) || (filter.Endereco == null))
                            )
                            select e;

                    List<DEEnderecoCliente> DEEnderecoCliente = q.ToList();

                    List<BEEnderecoCliente> retorno = new List<BEEnderecoCliente>();

                    foreach (DEEnderecoCliente de in DEEnderecoCliente)
                        retorno.Add(de.ConvertToBE(1));

                    return retorno;
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        #endregion

        #region Métodos Auxiliares

        public BEEnderecoCliente BuscarEnderecoExistente(FEEnderecoCliente filter)
        {
            try
            {
                using (dc = new databaseDataContext())
                {
                    var q = from e in dc.DEEnderecoClientes
                            where
                            (
                                e.CodigoCliente == filter.CodigoCliente &&
                                e.Endereco.ToUpper() == filter.Endereco.ToUpper()
                            )
                            select e;

                    DEEnderecoCliente retorno = dc.DEEnderecoClientes.FirstOrDefault(e => e.CodigoCliente == filter.CodigoCliente &&
                                                                            e.Endereco.ToUpper() == filter.Endereco.ToUpper());

                    if (retorno != null)
                        return retorno.ConvertToBE(0);
                    else
                        return null;
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        private int Incluir(BEEnderecoCliente entidade)
        {
            try
            {
                using (dc = new databaseDataContext())
                {

                    DEEnderecoCliente de = new DEEnderecoCliente();
                    de.ConvertFromBE(entidade);

                    dc.DEEnderecoClientes.InsertOnSubmit(de);

                    dc.SubmitChanges();

                    return de.Codigo;
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        private void Alterar(BEEnderecoCliente entidade)
        {
            try
            {
                using (dc = new databaseDataContext())
                {

                    var q = from e in dc.DEEnderecoClientes
                            where e.Codigo == entidade.Codigo
                            select e;

                    DEEnderecoCliente de = q.First();

                    de.CodigoCliente = entidade.CodigoCliente;
                    de.Endereco = entidade.Endereco;
                    de.PontoReferencia = entidade.PontoReferencia;
                    de.Principal = entidade.Principal;

                    dc.SubmitChanges();
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        #endregion
    }
}
